.TH std::shared_lock 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::shared_lock \- std::shared_lock

.SH Synopsis
   Defined in header <shared_mutex>
   template< class Mutex >           \fI(since C++14)\fP
   class shared_lock;

   The class shared_lock is a general-purpose shared mutex ownership wrapper allowing
   deferred locking, timed locking and transfer of lock ownership. Locking a
   shared_lock locks the associated shared mutex in shared mode (to lock it in
   exclusive mode, std::unique_lock can be used).

   The shared_lock class is movable, but not copyable – it meets the requirements of
   MoveConstructible and MoveAssignable but not of CopyConstructible or CopyAssignable.

   shared_lock meets the Lockable requirements. If Mutex meets the SharedTimedLockable
   requirements, shared_lock also meets TimedLockable requirements.

   In order to wait in a shared mutex in shared ownership mode,
   std::condition_variable_any can be used (std::condition_variable requires
   std::unique_lock and so can only wait in unique ownership mode).

.SH Template parameters

   Mutex - the type of the shared mutex to lock. The type must meet the SharedLockable
           requirements

.SH Member types

   Type       Definition
   mutex_type Mutex

.SH Member functions

   constructor    constructs a shared_lock, optionally locking the supplied mutex
                  \fI(public member function)\fP
   destructor     unlocks the associated mutex
                  \fI(public member function)\fP
   operator=      unlocks the mutex, if owned, and acquires ownership of another
                  \fI(public member function)\fP
.SH Shared locking
   lock           locks the associated mutex
                  \fI(public member function)\fP
   try_lock       tries to lock the associated mutex
                  \fI(public member function)\fP
   try_lock_for   tries to lock the associated mutex, for the specified duration
                  \fI(public member function)\fP
   try_lock_until tries to lock the associated mutex, until a specified time point
                  \fI(public member function)\fP
   unlock         unlocks the associated mutex
                  \fI(public member function)\fP
.SH Modifiers
   swap           swaps the data members with another shared_lock
                  \fI(public member function)\fP
   release        disassociates the mutex without unlocking
                  \fI(public member function)\fP
.SH Observers
   mutex          returns a pointer to the associated mutex
                  \fI(public member function)\fP
   owns_lock      tests whether the lock owns its associated mutex
                  \fI(public member function)\fP
   operator bool  tests whether the lock owns its associated mutex
                  \fI(public member function)\fP

.SH Non-member functions

   std::swap(std::shared_lock) specialization of std::swap for shared_lock
   \fI(C++14)\fP                     \fI(function template)\fP

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to              Behavior as published              Correct behavior
   LWG 2981 C++17      redundant deduction guide from                  removed
                       shared_lock<Mutex> was provided
